// pages/home/index.js
Page({
  data: {
    // 轮播图数据
    bannerList: [
      { id: 1, image: 'cloud://shengyi-cloudbase-4e8hy10f8ba1e2.7368-shengyi-cloudbase-4e8hy10f8ba1e2-1372738167/shengyi_miniprogram/content/home/banner_1.jpg' },
      { id: 2, image: 'cloud://shengyi-cloudbase-4e8hy10f8ba1e2.7368-shengyi-cloudbase-4e8hy10f8ba1e2-1372738167/shengyi_miniprogram/content/home/banner_2.jpg' },
      { id: 3, image: 'cloud://shengyi-cloudbase-4e8hy10f8ba1e2.7368-shengyi-cloudbase-4e8hy10f8ba1e2-1372738167/shengyi_miniprogram/content/home/banner_3.jpg' }
    ],
    
    // 关于圣义轮播图数据 - 广告公司展示
    aboutShengyiList: [
      { 
        id: 1, 
        image: 'cloud://shengyi-cloudbase-4e8hy10f8ba1e2.7368-shengyi-cloudbase-4e8hy10f8ba1e2-1372738167/shengyi_miniprogram/content/home/company_1.png'
      },
      { 
        id: 2, 
        image: 'cloud://shengyi-cloudbase-4e8hy10f8ba1e2.7368-shengyi-cloudbase-4e8hy10f8ba1e2-1372738167/shengyi_miniprogram/content/home/company_2.png'
      },
      { 
        id: 3, 
        image: 'cloud://shengyi-cloudbase-4e8hy10f8ba1e2.7368-shengyi-cloudbase-4e8hy10f8ba1e2-1372738167/shengyi_miniprogram/content/home/company_3.png'
      },
      { 
        id: 4, 
        image: 'cloud://shengyi-cloudbase-4e8hy10f8ba1e2.7368-shengyi-cloudbase-4e8hy10f8ba1e2-1372738167/shengyi_miniprogram/content/home/company_4.png'
      },
      { 
        id: 5, 
        image: 'cloud://shengyi-cloudbase-4e8hy10f8ba1e2.7368-shengyi-cloudbase-4e8hy10f8ba1e2-1372738167/shengyi_miniprogram/content/home/company_5.png'
      }
    ],
    
    // 登录相关数据
    memberLevel: '普通会员',
    balance: '¥0.00',
    points: '0',
    isLoggedIn: false,
    userInfo: null,
    
    // 活动中心数据 - 从云数据库获取
    activityList: [],
    
    
    // 商品数据 - 从云数据库获取推荐商品
    productList: [],
    
    searchKeyword: '',
    filteredProductList: [],
    displayActivities: [] // 用于显示的简化活动列表
  },

  onLoad() {
    console.log('Home页面加载');
    
    // 检查登录状态
    this.checkLoginStatus();
    
    // 加载活动数据
    this.loadActivities();
    
    // 加载推荐商品数据
    this.loadRecommendedGoods();
  },

  onShow() {
    if (typeof this.getTabBar === 'function' && this.getTabBar()) {
      this.getTabBar().setData({
        selected: 0
      });
    }
    // 检查登录状态，使用缓存机制减少云端调用
    this.checkLoginStatus();
    console.log('Home页面显示，当前displayActivities：', this.data.displayActivities);
  },

  onSearchInput(e) {
    const keyword = e.detail.value.toLowerCase();
    this.setData({ searchKeyword: keyword });
    
    const filteredList = keyword 
      ? this.data.productList.filter(product => 
          product.name.toLowerCase().includes(keyword) ||
          product.description.toLowerCase().includes(keyword)
        )
      : this.data.productList;
    
    this.setData({ filteredProductList: filteredList });
  },

  /**
   * 加载推荐商品数据
   */
  async loadRecommendedGoods() {
    try {
      wx.showLoading({
        title: '加载商品中...',
        mask: true
      })

      const result = await wx.cloud.callFunction({
        name: 'getGoods',
        data: {
          recommended: 1, // 只获取推荐商品
          limit: 6, // 首页显示6个推荐商品
          skip: 0,
          orderBy: 'sales',
          orderType: 'desc'
          // status: 1 的筛选已在云函数中处理
        }
      })

      console.log('推荐商品数据获取结果：', result)

      if (result.result && result.result.success) {
        const goods = result.result.data || []
        
        // 处理商品数据，确保字段兼容
        const processedGoods = goods.map(item => ({
          ...item,
          id: item._id || item.id,
          // 兼容原有字段名
          name: item.name,
          price: item.price,
          description: item.description,
          image: item.image
        }))

        this.setData({
          productList: processedGoods,
          filteredProductList: processedGoods
        })

        console.log('推荐商品数据加载成功，共', processedGoods.length, '个商品')
      } else {
        console.error('推荐商品数据获取失败：', result.result?.message || '未知错误')
        wx.showToast({
          title: '商品数据加载失败',
          icon: 'none',
          duration: 2000
        })
      }
    } catch (error) {
      console.error('加载推荐商品数据出错：', error)
      wx.showToast({
        title: '网络错误，请重试',
        icon: 'none',
        duration: 2000
      })
    } finally {
      wx.hideLoading()
    }
  },

  /**
   * 加载推荐活动数据
   */
  async loadActivities() {
    try {
      wx.showLoading({
        title: '加载中...',
        mask: true
      })

      const result = await wx.cloud.callFunction({
        name: 'getActivities',
        data: {
          category: 'all',
          limit: 10,
          skip: 0,
          orderBy: 'createdAt',
          orderType: 'desc'
        }
      })

      console.log('活动数据获取结果：', result)

      if (result.result && result.result.success) {
        const activities = result.result.data || []
        
        // 筛选推荐活动（recommended字段为1的活动）
        const recommendedActivities = activities.filter(activity => activity.recommended === 1)
        
        // 为每个活动添加一个唯一的 _id 作为 id（如果没有的话）
        const processedActivities = recommendedActivities.map(activity => ({
          ...activity,
          id: activity._id || activity.id
        }))

        this.setData({
          activityList: processedActivities,
          displayActivities: processedActivities.slice(0, 5) // 轮播显示最多5个推荐活动
        })

        console.log('推荐活动数据加载成功，共', processedActivities.length, '个推荐活动')
        console.log('首页轮播显示活动：', this.data.displayActivities)
        
        // 调试：打印每个活动的详细信息
        this.data.displayActivities.forEach((activity, index) => {
          console.log(`活动${index + 1}详细信息:`, {
            id: activity.id || activity._id,
            title: activity.title,
            eventTitle: activity.eventTitle,
            startTime: activity.startTime,
            location: activity.location,
            bannerImage: activity.bannerImage,
            image: activity.image,
            status: activity.status,
            recommended: activity.recommended
          })
        })
      } else {
        console.error('活动数据获取失败：', result.result?.message || '未知错误')
        wx.showToast({
          title: '活动数据加载失败',
          icon: 'none',
          duration: 2000
        })
      }
    } catch (error) {
      console.error('加载活动数据出错：', error)
      wx.showToast({
        title: '网络错误，请重试',
        icon: 'none',
        duration: 2000
      })
    } finally {
      wx.hideLoading()
    }
  },

  /**
   * 检查登录状态并同步用户信息（带缓存优化）
   */
  async checkLoginStatus(forceRefresh = false) {
    const userInfo = wx.getStorageSync('userInfo')
    const isLoggedIn = wx.getStorageSync('isLoggedIn')
    
    if (isLoggedIn && userInfo && userInfo._openid) {
      try {
        // 检查缓存是否有效，除非强制刷新
        if (!forceRefresh && this.isCacheValid()) {
          const cachedUserInfo = this.getCachedUserInfo()
          if (cachedUserInfo) {
            console.log('使用缓存的用户信息')
            this.setDataWithLocalData(cachedUserInfo)
            return
          }
        }
        
        // 缓存无效或强制刷新，从云端同步
        console.log('从云端同步用户信息...')
        const cloudUserInfo = await this.syncUserInfoFromCloud(userInfo._openid)
        if (cloudUserInfo.success) {
          // 更新本地存储和缓存
          wx.setStorageSync('userInfo', cloudUserInfo.data)
          this.setCachedUserInfo(cloudUserInfo.data)
          
          this.setData({
            isLoggedIn: true,
            userInfo: cloudUserInfo.data,
            memberLevel: cloudUserInfo.data.memberLevelInfo?.name || '普通会员',
            balance: `¥${cloudUserInfo.data.balance?.toFixed(2) || '0.00'}`,
            points: cloudUserInfo.data.totalPoints?.toString() || '0'
          })
        }
      } catch (error) {
        console.error('同步用户信息失败:', error)
        const errorMessage = error.message || ''
        
        // 检查是否是用户不存在或被禁用的错误
        if (errorMessage.includes('用户不存在') || errorMessage.includes('用户已被禁用')) {
          // 这些错误已经在 syncUserInfoFromCloud 中处理了，这里不再重复处理
          console.log('用户状态异常已在前一步处理')
        } else {
          // 其他错误（如网络错误），使用本地数据
          this.setDataWithLocalData(userInfo)
        }
      }
    } else {
      // 未登录状态
      this.setData({
        isLoggedIn: false,
        userInfo: null,
        memberLevel: '---',
        balance: '---',
        points: '---'
      })
    }
  },

  /**
   * 获取缓存的用户信息
   */
  getCachedUserInfo() {
    const cachedData = wx.getStorageSync('cachedUserInfo')
    console.log('获取缓存数据:', cachedData)
    return cachedData ? cachedData.userInfo : null
  },

  /**
   * 设置缓存的用户信息
   */
  setCachedUserInfo(userInfo) {
    const cacheData = {
      userInfo: userInfo,
      timestamp: Date.now()
    }
    wx.setStorageSync('cachedUserInfo', cacheData)
  },

  /**
   * 检查缓存是否有效（10分钟）
   */
  isCacheValid() {
    const CACHE_DURATION = 10 * 60 * 1000 // 10分钟
    const cachedData = wx.getStorageSync('cachedUserInfo')
    
    if (!cachedData || !cachedData.timestamp) {
      return false
    }
    
    return Date.now() - cachedData.timestamp < CACHE_DURATION
  },

  /**
   * 使用本地数据设置页面状态
   */
  setDataWithLocalData(userInfo) {
    this.setData({
      isLoggedIn: true,
      userInfo: userInfo,
      memberLevel: userInfo.memberLevelInfo?.name || '普通会员',
      balance: `¥${userInfo.balance?.toFixed(2) || '0.00'}`,
      points: userInfo.totalPoints?.toString() || '0'
    })
  },

  /**
   * 从云端同步用户信息（增强版）
   */
  async syncUserInfoFromCloud(openid) {
    return new Promise((resolve, reject) => {
      if (!wx.cloud) {
        reject(new Error('云开发未初始化'))
        return
      }

      console.log('开始调用 getUserInfo 云函数...')

      wx.cloud.callFunction({
        name: 'getUserInfo',
        data: {},
        success: res => {
          console.log('云函数返回结果:', res)
          
          if (res.result && res.result.success) {
            console.log('用户信息获取成功:', res.result.data)
            resolve(res.result)
          } else {
            const errorMsg = res.result?.message || '获取用户信息失败'
            const errorCode = res.result?.error || 'UNKNOWN_ERROR'
            
            // 处理用户不存在或被禁用的情况
            if (errorCode === 'USER_NOT_FOUND' || errorCode === 'USER_DISABLED') {
              console.log('用户不存在或已被禁用，清除本地登录状态')
              
              // 清除本地存储的用户信息
              wx.removeStorageSync('userInfo')
              wx.removeStorageSync('isLoggedIn')
              wx.removeStorageSync('cachedUserInfo')
              
              // 更新页面状态为未登录
              this.setData({
                isLoggedIn: false,
                userInfo: null,
                memberLevel: '---',
                balance: '---',
                points: '---'
              })
              
              // 显示提示信息
              wx.showToast({
                title: errorMsg,
                icon: 'none',
                duration: 2000
              })
            }
            
            reject(new Error(errorMsg))
          }
        },
        fail: error => {
          console.error('云函数调用失败:', error)
          reject(new Error(`云函数调用失败: ${error.errMsg || error.message}`))
        }
      })
    })
  },

  /**
   * 登录/注册按钮点击 - 直接跳转到登录页面
   */
  onAuthTap() {
    if (this.data.isLoggedIn) {
      // 已登录，跳转到个人中心
      wx.navigateTo({
        url: '/pages/profile/index'
      })
    } else {
      // 未登录，直接跳转到登录页面
      wx.navigateTo({
        url: '/pages/login/index'
      })
    }
  },

  /**
   * 点击会员信息显示区域 - 跳转到会员中心
   */
  onVipCenterTap() {
    if (!this.data.isLoggedIn) {
      wx.navigateTo({
        url: '/pages/login/index'
      })
      return false
    }
    
    wx.navigateTo({
      url: '/pages/vip_center/index'
    })
  },

  /**
   * 搜索栏点击事件 - 跳转到搜索页面
   */
  onSearchTap() {
    wx.navigateTo({
      url: '/pages/search/index'
    });
  },

  /**
   * 关于圣义轮播图点击事件 - 图片预览
   */
  onAboutShengyiTap(e) {
    const index = e.currentTarget.dataset.index;
    const current = this.data.aboutShengyiList[index].image;
    const urls = this.data.aboutShengyiList.map(item => item.image);
    
    wx.previewImage({
      current: current,
      urls: urls,
      success: () => {
        console.log('图片预览成功');
      },
      fail: (err) => {
        console.error('图片预览失败:', err);
        wx.showToast({
          title: '图片加载失败',
          icon: 'none',
          duration: 2000
        });
      }
    });
  },

  /**
   * 商品点击事件
   */
  onProductTap(e) {
    const productId = e.currentTarget.dataset.id;
    console.log('点击商品:', productId);
    wx.navigateTo({
      url: `/pages/goods_detail/index?id=${productId}`
    });
  },


  // 推荐活动轮播卡片点击事件
  onActivityCardTap(e) {
    let item, activityId;
    
    // 处理不同的事件来源
    if (e.detail && e.detail.item) {
      // 来自瀑布流组件的事件
      item = e.detail.item;
      activityId = item._id || item.id;
    } else if (e.currentTarget && e.currentTarget.dataset && e.currentTarget.dataset.item) {
      // 来自轮播组件的事件
      item = e.currentTarget.dataset.item;
      activityId = item._id || item.id;
    } else {
      console.error('无法获取活动数据:', e);
      wx.showToast({
        title: '活动信息错误',
        icon: 'none',
        duration: 2000
      })
      return
    }
    
    console.log('点击推荐活动卡片，ID:', activityId, '数据:', item);
    
    if (!activityId) {
      wx.showToast({
        title: '活动信息错误',
        icon: 'none',
        duration: 2000
      })
      return
    }
    
    wx.navigateTo({
      url: `/pages/activity_detail/index?id=${activityId}`,
      success: () => {
        console.log('成功跳转到活动详情页');
      },
      fail: (err) => {
        console.error('跳转失败:', err);
        wx.showToast({
          title: '页面跳转失败',
          icon: 'none',
          duration: 2000
        })
      }
    });
  },

  // 跳转到活动页面（第二个tab）
  viewMoreActivities() {
    console.log('点击查看更多推荐活动');
    wx.switchTab({
      url: '/pages/activity/index',
      success: () => {
        console.log('成功跳转到活动页面');
      },
      fail: (err) => {
        console.error('跳转活动页面失败:', err);
        wx.showToast({
          title: '页面跳转失败',
          icon: 'none',
          duration: 2000
        })
      }
    });
  },

  // 跳转到商品页面（第二个tab）
  viewMoreProducts() {
    wx.switchTab({
      url: '/pages/shop/index'
    });
  },

  /**
   * 静默登录 - 通过openid检查用户是否存在并直接登录
   */
  async silentLoginWithOpenId() {
    wx.showLoading({ title: '验证登录...' })
    
    try {
      // 1. 获取微信登录凭证
      const loginRes = await this.wxLogin()
      
      // 2. 调用云函数检查用户是否存在
      const checkResult = await this.checkCloudUser(loginRes.code)
      
      if (checkResult.success && checkResult.exists) {
        // 用户存在，直接登录
        const cloudResult = await this.cloudLogin(loginRes.code, { userInfo: {} })
        
        if (cloudResult.success) {
          // 保存用户信息到本地
          wx.setStorageSync('userInfo', cloudResult.data)
          wx.setStorageSync('isLoggedIn', true)
          
          // 执行完整数据刷新，确保用户信息完整
          await this.checkLoginStatus(true)
          
          // 静默完成，不显示提示
        } else {
          throw new Error(cloudResult?.message || '登录失败')
        }
      } else {
        // 用户不存在，跳转到登录页面
        wx.navigateTo({
          url: '/pages/login/index'
        })
      }
    } catch (error) {
      console.error('静默登录失败:', error)
      // 出错时跳转到登录页面
      wx.navigateTo({
        url: '/pages/login/index'
      })
    } finally {
      wx.hideLoading()
    }
  },

  /**
   * 微信登录获取code
   */
  wxLogin() {
    return new Promise((resolve, reject) => {
      wx.login({
        success: resolve,
        fail: reject
      })
    })
  },

  /**
   * 检查云端用户状态
   */
  async checkCloudUser(code) {
    return new Promise((resolve, reject) => {
      if (!wx.cloud) {
        reject(new Error('云开发未初始化'))
        return
      }

      console.log('调用云函数checkUser，参数:', { code })
      
      wx.cloud.callFunction({
        name: 'checkUser',
        data: { code },
        success: res => {
          console.log('checkUser云函数调用成功:', res)
          if (res.result) {
            resolve(res.result)
          } else {
            reject(new Error('云函数返回数据格式错误'))
          }
        },
        fail: error => {
          console.error('checkUser云函数调用失败:', error)
          reject(error)
        }
      })
    })
  },

  /**
   * 云函数登录
   */
  async cloudLogin(code, userProfile) {
    return new Promise((resolve, reject) => {
      if (!wx.cloud) {
        reject(new Error('云开发未初始化'))
        return
      }

      console.log('调用云函数login，参数:', { code, userInfo: userProfile.userInfo })
      
      wx.cloud.callFunction({
        name: 'login',
        data: {
          code: code,
          userInfo: userProfile.userInfo
        },
        success: res => {
          console.log('云函数调用成功:', res)
          if (res.result) {
            resolve(res.result)
          } else {
            reject(new Error('云函数返回数据格式错误'))
          }
        },
        fail: error => {
          console.error('云函数调用失败:', error)
          reject(error)
        }
      })
    })
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  async onPullDownRefresh() {
    try {
      // 并行刷新用户信息、活动数据和商品数据
      await Promise.all([
        this.checkLoginStatus(true),
        this.loadActivities(),
        this.loadRecommendedGoods()
      ])
      
      // 显示刷新成功提示
      wx.showToast({
        title: '刷新成功',
        icon: 'success',
        duration: 1000
      })
    } catch (error) {
      console.error('下拉刷新失败:', error)
      wx.showToast({
        title: '刷新失败',
        icon: 'none',
        duration: 1000
      })
    } finally {
      // 停止下拉刷新动画
      wx.stopPullDownRefresh()
    }
  }
})